/**
 * @param{Number} a
 * @param{Number} b
 * @returns{Number} 
 * 最大公约数和最小公倍数
 * 返回的结果为最大公约数以及最小公倍数
 */
 function MaxDivisor ( a , b ) {
    var temp = a ; 
    if ( b > a ) {
        a = b ;
        b = temp ; 
    }
    while ( a % b != 0 ) {      //辗转相除法
        temp = b ; 
        b = a % b ; 
        a = temp ; 
    }
    return b ; 
}
function MinMulti ( a , b ) {
    var res = MaxDivisor( a , b ) ;
    return a * b / res ;
} 
/**
 * 判断是否为质数
 * @param{Number} a 
 * 是质数则返回true，不是质数则返回false
 */
function isPrime( a ) {
    var count = 0 ; 
    for( var i = 1 ; i <= a ; i ++ ) {
        if ( a % i == 0 ) {
            count ++ ;
        }
    }
    if ( count == 2 ) {
        return true ;
    } else {
        return false ; 
    }
}

/**
 * @param{Array} arr
 * 计数排序
 * 返回的结果为计数排序之后的升序新数组
 */
 function countSort( arr ) {
    var newArr = [] ; 
    for( let i = 0 ; i < arr.length ; i ++ ) { 
        if( newArr[arr[i]] == undefined ) {
            newArr[arr[i]] = 1 ; 
        } else {
            newArr[arr[i]] ++ ;
        }
    }
    var newArr2 = [] ;
    for( let i = 0 ; i < newArr.length ; i ++ ){        //这里改变降序还是升序，正序升倒序降
        if ( newArr[i] !== undefined ) {
            for( let j = 1 ; j <= newArr[i] ; j ++ ){
                newArr2.push(i);
            }
        }
    }
    return newArr2 ;     
}

/**
 * 冒泡排序
 * @param{Array} arr
 * 返回值为排序后的原数组
 * 升序排列
 */
function bubSort( arr ) {
    for ( var i = 0 ; i < arr.length ; i ++ ){
        for ( var j = 0 ; j < arr.length - 1 ; j ++ ){
            if ( arr[j] > arr[j+1] ) {              //控制升序还是降序   > 升   < 降
                var temp = arr[j] ; 
                arr[j] = arr[j + 1] ;
                arr[j + 1] = temp ;
            }
        }
    }
    return arr ;
}

/**
 * 选择排序
 * @param{Array} arr 
 * 选择排序
 * 返回值是升序排列的原数组
 */
function selectSort( arr ){
    for ( var i = 0 ; i < arr.length ; i ++ ) {
        var minIndex = i ;
        for ( var j = i ; j < arr.length ; j ++ ) {
            if ( arr[minIndex] > arr[j] ) {         //控制升序与降序  > 升   < 降
                minIndex = j ; 
            }
        }
        var temp = arr[minIndex] ;
        arr[minIndex] = arr[i] ; 
        arr[i] = temp ;
    }
    return arr ; 
}

/**
 * 数组与字符串的去重
 * @param{arg} arg 
 * 如果实参为字符串，则返回值去重之后的字符串
 * 如果实参是数组，则返回值是去重之后的数组
 */
// 去重1，一般方法去重
function NoRepeat1 ( arg ) { 
    var newArg = [] ;
    if (typeof arg == 'string' ) {
        for( var i = 0 ; i < arg.length ; i ++ ) {
            if ( newArg.indexOf( arg[i] ) == -1 ){
                newArg.push( arg[i] ) ; 
            }
        }
        return newArg.join("") ; 
    } else if ( typeof arg == 'object' ){
        for( var i = 0 ; i < arg.length ; i ++ ) {
            if ( newArg.indexOf( arg[i] ) == -1 ){
                newArg.push( arg[i] ) ; 
            }
        } 
        return newArg ; 
    }
}
// 去重2，利用对象键名不重复性去重
function NoRepeat2 ( arg ) {
    var obj = {} ; 
    for ( var i = 0 ; i < arg.length ; i ++ ){
        obj[arg[i]] = 1 ; 
    }
    var newArr = [] ;
    for ( var key in obj ) {
        newArr.push(key);
    }
    if (typeof arg == 'string' ){
        return newArr.join("");
    } else if ( typeof arg == 'object' ){
        return newArr ;
    }
}
//去重3 利用集合元素的不重复性
function NoRepeat3 ( arg ) {
    var newArg = new Set(arg);
    var newArr = Array.from(newArg);
    if ( typeof arg == 'string' ){
        return newArr.join("") ; 
    } else if ( typeof arg == 'object' ){
        return newArr ;
    }
}

/**
 * 数组拼接
 * @param{Array} arr1
 * @param{Array} arr2
 * 返回值是拼接之后的数组
 */
function conArr ( arr1 , arr2 ) {
    var newArr = arr1.concat(arr2) ;
    return newArr ;
}

/**
 * 数组中元素在数组中出现次数
 * @param{Array} arr
 * 
 * 返回值为一个对象，键名为数组元素，键值为出现次数
 */
function CountWord ( arr ) {
    var obj = {} ; 
    for ( var i = 0 ; i < arr.length ; i ++ ) {
        if( obj[arr[i]] == undefined ) {
            obj[arr[i]] = 1 ; 
        } else {
            obj[arr[i]] ++ ;
        }
    }
    return obj ; 
}

/**
 * 获得一个随机数
 * @param{Number}} max
 * @param{Number}} min
 * 返回值为最大值与最小值之间的一个随机数
 */
function getRandom ( max , min ) {
    var res = parseInt(Math.random() * ( max + 1 - min )) + min ; 
    return res ; 
}